package src.application.Doppelkopf;

import java.util.ArrayList;

/**
* Klasse die die Computer Spieler steuert. Hier wird die KI implementiert
* Ben�tigt wird:
* 	- der aktuelle Stich 
* 	- Spieler die zusammen spielen falls bekannt
* 	- Karten Reihenfolge
*  - Spielerart(Solo, ...)
*  
*  
* 	
*/
public class CpuSpieler extends Spieler 
{
    private int[] parteien;
    private int spielart;
    private int aufspiel;
    private Karte hoechsteKarteImSpiel;
    private int anzHoechsteKarte = 2;
   
    public CpuSpieler()
    {
        super();
        parteien=new int[]{0,0,0,0};
        spielart=0;
    }
    
    /**
     * Setzt die höchste karte
     * @param high
     * @param anz 
     */
    private void setHoechsteKarte(Karte high, int anz)
    {
        
    }
    

    /**
     * 
     * @return 
     */ 
    @Override
    public String karteSpielen() 
    {
        Karte[] spielbar = spielbareKarten();
        String ret = "";
        Karte retKarte;
        // Normalspiel
        if (spielart==0)
        // eigenes Aufspiel
        {
            if (aufspiel==0)
            {
                // Ass von einer Farbe
            }
            else
            {
                // nur eine Karte möglich
                if (spielbar[1]==null)
                {
                    retKarte = spielbar[0];
                    // Karte zum String
                }
                // Trumpf aufgespielt
                else if (stich[0].getTrumpf())
                {
                    // Trumpf aufgespielt
                }
                //Fehl aufgespielt
                else
                {
                    
                }
            }
        
        }
        else 
        {
            
        }
        return "";  //ergab nen fehler, daher einfach mal eingefügt. musst du noch ändern!!!
    }

    /**
     * erstmal weg!
     * @return 
     */
    @Override
    public int macheAnsage() 
    {
       
        
        
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * 
     * @return 
     */
    @Override
    public int[] getVorbehalte() 
    {
        int[] vorbehalt = new int[4];
        boolean hochzeit, schweine, dsolo, bsolo, flos, schmeißen;
        int anzKoenige=0, punkte=0, anzAsse, anzDamen, anzBuben, anz[];
        
        //Hochzeit überprüfen
        //Schweine überprüfen
        for (int i=0; i<handkarten.length-1; i++)
        {
            if ((handkarten[i].getFarbe()=='d') && (handkarten[i].getWert()==11)
                && (handkarten[i+1].getFarbe()=='d') && (handkarten[i+1].getWert()==11))
                schweine=true;
            
            if ((handkarten[i].getFarbe()=='k') && (handkarten[i].getWert()==3)
                && (handkarten[i+1].getFarbe()=='k') && (handkarten[i+1].getWert()==3))
                hochzeit=true;
        }
        
        //Soli überprüfen
        anz = zaehlen();
        anzAsse= anz[3];
        anzDamen = anz[1];
        anzBuben = anz[0];
        anzKoenige = anz[2];
        punkte = anz[4];
        
        //Damen Solo
        dsolo =damenSolo(anzDamen, anzAsse);
        
        //Buben Solo
        bsolo = bubenSolo(anzBuben, anzAsse);
         
        //Fleischlos
        flos = assSolo(anzAsse);
        
        //Schmeißen überprüfen    
        if ((punkte >=80)||(anzKoenige>=5))
        {
            schmeißen = true;
        }
        
        // Vorbehalte zusammenfassen
        int[] tmp = new int[1];
        return tmp;
    }
    
    /**
     * 
     * @param anzDamen
     * @param anzAsse
     * @return 
     */
    private boolean damenSolo(int anzDamen, int anzAsse)
    {
        if ((anzDamen>4) && (anzAsse>=3) && (aufspiel==0))
        {
            for (int i=handkarten.length-1; i>0; --i)
            {
                // Überprüfen ob min 2 hohe Damen dabei sind
                if ((handkarten[i].getFarbe()=='k') && (handkarten[i].getWert()==3)
                    && (((handkarten[i-1].getFarbe()=='k') && (handkarten[i-1].getWert()==3)
                        ||((handkarten[i-1].getFarbe()=='p') && (handkarten[i-1].getWert()==3)))))
                {
                    return  true;
                }     
            }
        }
        else if ((anzDamen>4) && (anzAsse>=3) && (aufspiel!=0))
        {
            for (int i=handkarten.length-1; i>0; --i)
            {
                // Überprüfen ob min 2 Kreuz Damen dabei sind
                if ((handkarten[i].getFarbe()=='k') && (handkarten[i].getWert()==3)
                    && (((handkarten[i-1].getFarbe()=='k') && (handkarten[i-1].getWert()==3))))
                {
                    return true;
                }     
            }
        }
        return false;
    }
    
    
    /**
     * Zählt alle wichtigen Karten.
     * Zum Überprüfen der Vorbehalte.
     * @return 0: Anzahl Buben <br>
     *         1: Anzahl Damen <br>
     *         2: Anzahl Könige<br>
     *         3: Anzahl Asse<br>
     *         4: Punkte<br>
     */
    private int[] zaehlen() 
    {
        int[] ret = new int[]{0,0,0,0,0};
        for (int i=0; i<handkarten.length; ++i)
        {
            switch (handkarten[i].getWert())
            {
                case 2: ret[0]++; break;
                case 3: ret[1]++; break;
                case 4: ret[2]++; break;
                case 11:ret[3]++; break;
                default: break;
            }
            ret[4]+= handkarten[i].getWert();
        }
        return ret;
    }

    /**
     * 
     * @param anzBuben
     * @param anzAsse
     * @return 
     */
    private boolean bubenSolo(int anzBuben, int anzAsse) 
    {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * 
     * @param anzAsse
     * @return 
     */
    private boolean assSolo(int anzAsse) 
    {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    
    /**
     * Bestimmt den aktuellen Stichgewinner
     * @return Position des Stichgewinners
     */
    private int aktStichGewinner()
    {
        int ret=0;
        Karte high=null;
        
        // Erste Karte noch nicht gespielt, man selbst gewinnt den Stich
        if (stich[0]== null)
        {
            return ret;
        }
        else
        {
            // Nur erste Karte gespielt
            if (stich[1]==null)
            {
                return ret;
            }
            // Zweite Karte gespielt, gucken welche Karte höher ist
            else if (stich[1].compareStichkarten(stich[0])>0)
            {
                high= stich[ret];
                ret = 1;
            }
            
            // Nur zwei Karten gespielt
            if(stich[2]==null)
            {
                return ret;
            }
            // Drei Karten gespielt, gucken ob höher als vorherige höchste
            else if (stich[2].compareStichkarten(high)>0)
            {
                ret = 2;
            }
            // stich[3] muss nicht überprüft werden, da Spieler höchstens am Ende sitzt
            
            // Rückgabe der Position des aktuellen Stichgewinners
            return ret;
        }
    }
    
}
